package test2;

/**
 * @author spf
 * @date 2024/10/11
 * @time 21:01
 */

//import java.util.Arrays;
//
///**
// * 瑞辛
// */
//public class Main6 {
//     public int maxFlavor (int[] price, int k) {
//        // write code here
//         Arrays.sort(price);
//
//         int n= price.length;
//         if(n<k){
//             return -1;
//         }
//
//         int maxDiff=0;
//
//         for (int i = 0; i <= n-k; i++){
//             int minDiff = Integer.MAX_VALUE;
//             for (int j = i; j < i+k-1; j++){
//                 minDiff = Math.min(minDiff, price[j+1]-price[j]);
//             }
//             maxDiff = Math.max(maxDiff, minDiff);
//         }
//         return maxDiff;
//     }
//}

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

//public class Main6 {
//    static class State {
//        int x, y, time, plates;
//
//        public State(int x, int y, int time, int plates) {
//            this.x = x;
//            this.y = y;
//            this.time = time;
//            this.plates = plates;
//        }
//    }
//
//    public static void main(String[] args) {
//        Scanner sc = new Scanner(System.in);
//        int n = sc.nextInt();
//        int T = sc.nextInt();
//        int[][] grid = new int[n][n];
//
//        for (int i = 0; i < n; i++) {
//            for (int j = 0; j < n; j++) {
//                grid[i][j] = sc.nextInt();
//            }
//        }
//
//        int[][] directions = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
//        int[][][] dp = new int[n][n][T + 1]; // dp[x][y][t] means max plates at (x, y) at time t
//        boolean[][][] visited = new boolean[n][n][T + 1];
//
//        Queue<State> queue = new LinkedList<>();
//        queue.add(new State(0, 0, 0, Integer.MAX_VALUE)); // Start at (1, 1) with unlimited plates
//        dp[0][0][0] = Integer.MAX_VALUE; // Initially, we can carry unlimited plates
//
//        while (!queue.isEmpty()) {
//            State current = queue.poll();
//            int x = current.x, y = current.y, time = current.time, plates = current.plates;
//
//            if (time > T) continue; // If we exceed the time limit, stop processing
//
//            for (int[] dir : directions) {
//                int nx = x + dir[0], ny = y + dir[1];
//                if (nx >= 0 && nx < n && ny >= 0 && ny < n) { // Ensure within bounds
//                    int maxPlates = grid[nx][ny] == -1 ? plates : Math.min(plates, grid[nx][ny]);
//                    if (time + 1 <= T && !visited[nx][ny][time + 1] && dp[nx][ny][time + 1] < maxPlates) {
//                        dp[nx][ny][time + 1] = maxPlates;
//                        visited[nx][ny][time + 1] = true;
//                        queue.add(new State(nx, ny, time + 1, maxPlates));
//                    }
//                }
//            }
//        }
//
//        int result = 0;
//        for (int t = 0; t <= T; t++) {
//            result = Math.max(result, dp[n - 1][n - 1][t]);
//        }
//
//        System.out.println(result == 0 ? 0 : result);
//    }
//}

import java.util.Arrays;
import java.util.Scanner;

public class Main6 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 读取输入
        int N = scanner.nextInt();
        int M = scanner.nextInt();
        int[] abilities = new int[N];
        for (int i = 0; i < N; i++) {
            abilities[i] = scanner.nextInt();
        }

        // 计算并输出结果
        System.out.println(maxGroups(N, M, abilities));

        scanner.close();
    }

    public static int maxGroups(int N, int M, int[] abilities) {
        // 将能力值按降序排列
        Arrays.sort(abilities);
        for (int i = 0; i < N / 2; i++) {
            int temp = abilities[i];
            abilities[i] = abilities[N - 1 - i];
            abilities[N - 1 - i] = temp;
        }

        int groups = 0;
        int i = 0;

        while (i < N) {
            // 当前小组的最高能力值
            int maxAbility = abilities[i];
            // 当前小组的成员数
            int groupSize = 1;

            // 尝试增加小组成员数，直到小组能处理的项目难度大于等于 M
            while (i + groupSize < N && groupSize * maxAbility < M) {
                groupSize += 1;
            }

            // 如果当前小组能处理项目难度大于等于 M，则计数加1
            if (groupSize * maxAbility >= M) {
                groups += 1;
                i += groupSize;
            } else {
                // 如果无法组成满足条件的小组，则跳出循环
                break;
            }
        }

        return groups;
    }
}
